Python 中 Redis 库分布式锁简单分析
The following article is from 懒编程 Author ayuliao
作者：ayuliao
来源：懒编程
简介
我们常会遇到某段逻辑在相同时间段内只希望被单个实例执行，而在微服务架构中，一个程序可能会存在多个实例，此时就需要通过分布式锁来实现串行执行。
最简单的分布式锁无非就是找到对于多个程序实例而言单一的存在，比如MySQL数据只有一个或Redis只有一个，此时都可以利用这单一的存在构建一个锁，多个程序实例要执行某段逻辑前必须先获得这个锁，然后才能执行。
因为某些原因，上班的时候我和同事一起研究了一下Python redis库中分布式锁的实现源码，这里简单分享一下。
通过pip可以安装这个库。
pip install redis==2.10.6
这里以这个库的2.10.6版本为例，对它Redis分布式锁源码进行简单的分析。
代码分析
实例化StrictRedis对象后，使用其中的lock方法便可获得一个分布式锁。
首先看一下lock方法对应的源码。
def lock(self, name, timeout=None, sleep=0.1, blocking_timeout=None,
lock_class=None, thread_local=True):
if lock_class is None:
if self._use_lua_lock is None:
# the first time .lock() is called, determine if we can use
# Lua by attempting to register the necessary scripts
try:
LuaLock.register_scripts(self)
self._use_lua_lock = True
except ResponseError:
self._use_lua_lock = False
lock_class = self._use_lua_lock and LuaLock or Lock
return lock_class(self, name, timeout=timeout, sleep=sleep,
blocking_timeout=blocking_timeout,
thread_local=thread_local)
该方法提供了多个参数，其中：
name用于指定锁名 timeout用于指定锁的超时时间 sleep用于指定线程睡眠时间，线程争夺锁的过程本质就是一个循环，每过sleep秒，就会尝试去获取锁对象 blocking_timeout用于指定阻塞超时时间，当多个实例争夺锁时，这个时间就是实例等待锁的最长时间 lock_class表示使用锁的类对象 thread_local表示是否线程安全
方法中最关键的一句代码为lock_class = self._use_lua_lock and LuaLock or Lock，确定了lock_class后，便实例化该lock_class即可。
lock_class可以为LuaLock也可为Lock，经过简单分析，Lock类才是关键，LuaLock类继承自Lock，通过Lua代码实现Redis的一些操作，这里着重看Lock类。
首先看到该类的__init__方法。
class Lock(object):
def __init__(self, redis, name, timeout=None, sleep=0.1,
blocking=True, blocking_timeout=None, thread_local=True):
self.redis = redis
self.name = name
self.timeout = timeout
self.sleep = sleep
self.blocking = blocking
self.blocking_timeout = blocking_timeout
self.thread_local = bool(thread_local)
self.local = threading.local() if self.thread_local else dummy()
self.local.token = None
if self.timeout and self.sleep > self.timeout:
raise LockError("'sleep' must be less than 'timeout'")
__init__方法初始化不同的属性，其中self.local为线程的本地字段，用于存储该线程特有的数据，不与其他线程进行共享。
此外，在__init__方法中对timeout与sleep进行的判断，如果线程等待锁时的睡眠时间大于锁的超时时间，则直接返回错误。
接着重点看Lock类中的acquire方法，该方法代码如下。
import time as mod_time
class Lock(object):
def acquire(self, blocking=None, blocking_timeout=None):
sleep = self.sleep
token = b(uuid.uuid1().hex)
if blocking is None:
blocking = self.blocking
if blocking_timeout is None:
blocking_timeout = self.blocking_timeout
stop_trying_at = None
if blocking_timeout is not None:
stop_trying_at = mod_time.time() + blocking_timeout
while 1:
if self.do_acquire(token):
self.local.token = token
return True
if not blocking:
return False
if stop_trying_at is not None and mod_time.time() > stop_trying_at:
return False
mod_time.sleep(sleep)
acquire方法的主逻辑就是一个死循环，在死循环中调用do_acquire方法获取Redis分布式锁，如果成功获得锁，则将token存储到当前线程的local对象中，如果没有获得，则判断blocking，如果blocking为Flase，则不再阻塞，直接返回结果，反之，则判断当前时间是否超过blocking_timeout，超过，同样返回False，反之，通过sleep方法让当前线程睡眠sleep秒。
进一步分析do_acquire方法，代码如下：
def do_acquire(self, token):
if self.redis.setnx(self.name, token):
if self.timeout:
# convert to milliseconds
timeout = int(self.timeout * 1000) # 转成毫秒
self.redis.pexpire(self.name, timeout)
return True
return False
do_acquire方法中，一开始通过redis的setnx方法将name对着作为key，token作为value，setnx方法只有在key不存的情况下，才能正常的将value存入Redis中，若key依存，该方法不做任何操作，此时就相当于没有获取到锁。
将token成功插入后，则判断有无超时时间，如果设置了timeout，则通过pexpire方法将redis中name这个key的超时设置一下，因为pexpire方法是以毫秒为单位的，所以需要先将timeout转换成毫秒单位。
如果没有设置timeout，那么name这个key只能通过do_release方法中的逻辑清除。
至此，我们清楚的知道了，Redis分布式锁的本质其实就是Redis中的一个key-value，非常简单...
理清锁的获取逻辑后，来看一下相应的释放逻辑，主要关注release方法，该方法代码如下。
def release(self):
"Releases the already acquired lock"
expected_token = self.local.token
if expected_token is None:
raise LockError("Cannot release an unlocked lock")
self.local.token = None
self.do_release(expected_token)
release方法中先将线程中的token取出，并将其置为None，然后调用do_release方法实现锁的释放，do_release方法代码如下。
def do_release(self, expected_token):
name = self.name
def execute_release(pipe):
lock_value = pipe.get(name)
if lock_value != expected_token:
raise LockError("Cannot release a lock that's no longer owned")
pipe.delete(name)
self.redis.transaction(execute_release, name)
do_release方法的逻辑非常简单，其主要逻辑在execute_release方法，通过Redis的transaction方法开启一个事务来执行execute_release方法中逻辑。
在execute_release中，首先通过get方法获取name这个key对应的value，获得后，通过delete方法将其删除，实现Redis分布式锁的释放。
blocking属性
观察到acquire方法的这段代码。
while 1:
if self.do_acquire(token):
self.local.token = token
return True
if not blocking:
return False
if stop_trying_at is not None and mod_time.time() > stop_trying_at:
return False
mod_time.sleep(sleep)
如果blocking为True，获取不到锁，则执行后面的逻辑，让线程睡眠，阻塞等待其他线程将锁释放；如果blocking为False，获取不到锁，则直接返回获取锁失败。
这就会引出几种情况，假设现在有线程A与线程B都需要执行相同的逻辑，执行前需要获取锁。
如果线程A在执行的过程中，线程B也要执行了，如果blocking为True，此时线程B会被阻塞，等待线程A是否Redis锁；如果blocking为False，线程B此时获取不到锁，不执行相同的逻辑。
如果线程A执行完了，此时线程B到来，如果blocking为True或False，此时线程B都不会被阻塞并成功拿到锁，执行相同的逻辑。
一个简单的结论是，blocking无法保证逻辑是否被单次执行，如果希望通过Redis分布式锁让逻辑只执行一次，依旧需要从业务层面做控制，比如MySQL中的业务数据是否被修改或Redis中是否记录这业务数据等。
结尾
现在很多业务都离不开Redis，它已经成为互联网中的基础设施了，Redis有很多有趣的内容可以跟大家分享。
前段时间看见Redis之父退居二线，说已经为Redis工作了10年了，每天都要revice、merge他人的代码，这种工作让他没有创造东西的快乐，所以决定退居二线，将Redis交由社区运营，这让我有些感慨，软件工程是创造性的工作，适当的放空、阅读与行业无关的书籍其实有助于激发创造力。
最后感谢你的阅读，我们下篇文章见。
近期热门文章推荐：